package com.demo.test.javabase;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * @author gy
 * @date 2022/12/28
 */
public class MyArray {
    @Test
    public void m1() {
//        dataType[] arrayRefVar = new dataType[arraySize];

        String[] strArr = new String[100];
        System.out.println(strArr.length);

        ArrayList<Integer> arrayList = new ArrayList<>();
        System.out.println(arrayList.toArray().length);
        System.out.println(arrayList.size());


    }

    @Test
    public void m2(){
        // 静态初始化
        int[] a1 = {1,2,3};
        Man[] mans = {new Man(1,1),new Man(2,2)};
        String[] sarr = {"a","b","c"};
        for (int i = 0; i < sarr.length; i++) {
            System.out.println("string 数组========"+sarr[i]);
        }
        for (int i = 0; i < mans.length; i++) {
            System.out.println(mans[i]);
        }
        // 动态初始化
        int[] a = new int[2];
        a[0]=1;
        a[1]=2;
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }

    class Man{
        private int id;
        private int age;

        public Man(int id, int age) {
            this.id = id;
            this.age = age;
        }

        @Override
        public String toString() {
            return "Man{" +
                    "id=" + id +
                    ", age=" + age +
                    '}';
        }
    }

    @Test
    public void m3(){
        int[] arrays = {1,2,3,4,5};

        // 打印全部的数组元素
        for (int i = 0; i < arrays.length ; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("====================");
        // 计算数组总和
        int sum = 0;
        for (int i = 0; i < arrays.length ; i++) {
            sum += arrays[i];
        }
        System.out.println("sum:"+sum);
        System.out.println("====================");
        // 查找最大值
        int max = arrays[0];
        for (int i = 1; i < arrays.length ; i++) {
            if (arrays[i] > max){
                max = arrays[i];
            }
        }
        System.out.println("max:"+max);
    }

    // 反转数组
    // 双指针
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }

    @Test
    public void m4(){
        // 多维数组
        int a[][] = new int[2][5];
    }

    @Test
    public void m5(){
        int[] arr = {1,2,3,4,5};
        int[] arr3 = {1,2,3,4,5};
        int[] arr2 = {1,2,3,5,4};
        System.out.println(Arrays.equals(arr, arr2));
        System.out.println(Arrays.equals(arr, arr3));
        System.out.println("++++++++++++++++++");
        // 给所有的元素重新赋值
//        Arrays.fill(arr, 6);
//        System.out.println(arr);
        // 二分查找 返回的是查找key的idx
        Arrays.binarySearch(arr,3);
        System.out.println(1);
    }

    @Test
    public void m6(){
        int[] a = {1,44,35,235,325,23,54,23,2};
        int[] sort = sort(a);// 调用我们自己写的
        System.out.println(Arrays.toString(sort));

    }

    // 冒泡排序
    // 1.比较数组中两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
    // 2.每一次比较，都会产生一个最大，或者最小的数字
    // 3.下一轮则可以少一次排序
    // 4.依次循环，直至结束
    public static int[] sort(int[] array){
        // 临时变量
        int temp = 0;

        // 外层循环，判断我们这个程序要走多少次
        for (int i = 0; i < array.length - 1; i++) {

            boolean flag = false;  // 通过flag标识位减少没有意义的比较

            // 内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {// -i 是应为每一轮循环完了都会有个最大数个最小数 都是放在数组的最后一位 ，这里-i是为了减少一次没有必要的循环
                if (array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }
        }
        return array;
    }



}
